import moment from 'moment';

/**
 * 格式化时间戳
 * @param {number|string} timestamp - 时间戳（秒或毫秒）
 * @param {string} format - 格式字符串，默认为 'YYYY-MM-DD HH:mm:ss'
 * @returns {string} 格式化后的时间字符串
 */
export const formatTimestamp = (timestamp, format = 'YYYY-MM-DD HH:mm:ss') => {
  if (!timestamp) return '-';
  
  // 判断时间戳是秒还是毫秒
  const time = timestamp.toString().length === 10 
    ? moment.unix(timestamp) 
    : moment(timestamp);
  
  return time.format(format);
};

/**
 * 渲染订单状态标签
 * @param {string} status - 订单状态
 * @param {string} type - 类型（order|process）
 * @returns {object} 状态配置对象
 */
export const getStatusConfig = (status, type = 'order') => {
  const configs = {
    order: {
      WAITING_CONFIRM: { color: 'gold', text: '待确认', icon: 'clock-circle' },
      CONFIRMED: { color: 'blue', text: '已确认', icon: 'check-circle' },
      COMPLETED: { color: 'green', text: '已完成', icon: 'check-circle' },
      CANCELLED: { color: 'red', text: '已取消', icon: 'close-circle' },
      REFUNDED: { color: 'orange', text: '已退款', icon: 'undo' },
    },
    process: {
      pending: { color: 'orange', text: '待处理', icon: 'clock-circle' },
      accepted: { color: 'blue', text: '已接单', icon: 'check-circle' },
      rejected: { color: 'red', text: '已拒绝', icon: 'close-circle' },
      completed: { color: 'green', text: '已完成', icon: 'check-circle' },
      cancelled: { color: 'gray', text: '已取消', icon: 'stop' },
    },
    used: {
      0: { color: 'orange', text: '未使用', icon: 'clock-circle' },
      1: { color: 'green', text: '已使用', icon: 'check-circle' },
    }
  };

  const config = configs[type]?.[status] || 
                { color: 'default', text: status || '未知', icon: 'question-circle' };
  
  return config;
};

/**
 * 渲染状态标签组件
 * @param {string} status - 状态值
 * @param {string} type - 类型
 * @param {object} props - 额外属性
 * @returns {JSX.Element} 状态标签
 */
export const renderStatusTag = (status, type = 'order', props = {}) => {
  const config = getStatusConfig(status, type);
  
  return (
    <span
      style={{
        color: config.color,
        backgroundColor: `${config.color}1A`,
        padding: '4px 8px',
        borderRadius: '4px',
        fontSize: '12px',
        display: 'inline-flex',
        alignItems: 'center',
        gap: '4px',
      }}
      {...props}
    >
      {config.text}
    </span>
  );
};

/**
 * 格式化金额
 * @param {number} amount - 金额（分）
 * @param {boolean} showUnit - 是否显示单位
 * @returns {string} 格式化后的金额
 */
export const formatAmount = (amount, showUnit = true) => {
  if (!amount && amount !== 0) return '-';
  
  const yuan = (amount / 100).toFixed(2);
  return showUnit ? `¥${yuan}` : yuan;
};

/**
 * 格式化手机号
 * @param {string} phone - 手机号
 * @returns {string} 格式化的手机号
 */
export const formatPhone = (phone) => {
  if (!phone) return '-';
  
  const phoneStr = phone.toString();
  if (phoneStr.length === 11) {
    return phoneStr.replace(/(\d{3})(\d{4})(\d{4})/, '$1****$3');
  }
  return phoneStr;
};

/**
 * 解析分页参数
 * @param {object} params - 查询参数
 * @returns {object} 分页参数对象
 */
export const parsePaginationParams = (params = {}) => {
  return {
    page: parseInt(params.page) || 1,
    pageSize: parseInt(params.pageSize) || 10,
    ...params,
  };
};

/**
 * 构建请求参数
 * @param {object} filters - 过滤条件
 * @returns {object} 请求参数
 */
export const buildRequestParams = (filters = {}) => {
  const params = {};
  
  Object.keys(filters).forEach(key => {
    const value = filters[key];
    if (value !== undefined && value !== null && value !== '') {
      params[key] = value;
    }
  });
  
  return params;
};

/**
 * 防抖函数
 * @param {function} func - 需要防抖的函数
 * @param {number} delay - 延迟时间（毫秒）
 * @returns {function} 防抖后的函数
 */
export const debounce = (func, delay) => {
  let timeoutId;
  return (...args) => {
    clearTimeout(timeoutId);
    timeoutId = setTimeout(() => func.apply(this, args), delay);
  };
};

/**
 * 节流函数
 * @param {function} func - 需要节流的函数
 * @param {number} delay - 延迟时间（毫秒）
 * @returns {function} 节流后的函数
 */
export const throttle = (func, delay) => {
  let lastCall = 0;
  return (...args) => {
    const now = Date.now();
    if (now - lastCall >= delay) {
      lastCall = now;
      return func.apply(this, args);
    }
  };
};

/**
 * 处理API错误
 * @param {object} error - 错误对象
 * @returns {string} 错误消息
 */
export const handleApiError = (error) => {
  if (error.response) {
    // 请求已发送，服务器响应了错误状态
    const { status, data } = error.response;
    
    switch (status) {
      case 400:
        return data.message || '请求参数错误';
      case 401:
        return '未授权，请重新登录';
      case 403:
        return '没有权限执行此操作';
      case 404:
        return '请求的资源不存在';
      case 500:
        return '服务器内部错误';
      default:
        return data.message || `请求失败 (${status})`;
    }
  } else if (error.request) {
    // 请求已发送，但没有收到响应
    return '网络连接失败，请检查网络后重试';
  } else {
    // 其他错误
    return error.message || '请求失败';
  }
};

/**
 * 验证表单数据
 * @param {object} formData - 表单数据
 * @param {object} rules - 验证规则
 * @returns {object} 验证结果
 */
export const validateForm = (formData, rules) => {
  const errors = {};
  
  Object.keys(rules).forEach(field => {
    const value = formData[field];
    const rule = rules[field];
    
    if (rule.required && (!value && value !== 0)) {
      errors[field] = rule.message || '该字段不能为空';
    } else if (rule.pattern && value && !rule.pattern.test(value)) {
      errors[field] = rule.message || '格式不正确';
    } else if (rule.validator && typeof rule.validator === 'function') {
      const error = rule.validator(value, formData);
      if (error) {
        errors[field] = error;
      }
    }
  });
  
  return {
    isValid: Object.keys(errors).length === 0,
    errors,
  };
};

/**
 * 获取门店选择器选项
 * @param {array} stores - 门店列表
 * @returns {array} 选择器选项
 */
export const getStoreOptions = (stores) => {
  if (!Array.isArray(stores)) return [];
  
  return stores.map(store => ({
    value: store.id,
    label: store.name,
  }));
};

/**
 * 获取状态筛选选项
 * @param {string} type - 类型
 * @returns {array} 筛选选项
 */
export const getStatusOptions = (type = 'order') => {
  const configs = {
    order: [
      { value: '', label: '全部状态' },
      { value: 'WAITING_CONFIRM', label: '待确认' },
      { value: 'CONFIRMED', label: '已确认' },
      { value: 'COMPLETED', label: '已完成' },
      { value: 'CANCELLED', label: '已取消' },
    ],
    process: [
      { value: '', label: '全部状态' },
      { value: 'pending', label: '待处理' },
      { value: 'accepted', label: '已接单' },
      { value: 'rejected', label: '已拒绝' },
      { value: 'completed', label: '已完成' },
    ],
  };
  
  return configs[type] || [];
};

/**
 * 深拷贝对象
 * @param {object} obj - 要拷贝的对象
 * @returns {object} 拷贝后的对象
 */
export const deepClone = (obj) => {
  if (obj === null || typeof obj !== 'object') return obj;
  if (obj instanceof Date) return new Date(obj.getTime());
  if (obj instanceof Array) return obj.map(item => deepClone(item));
  
  const cloned = {};
  Object.keys(obj).forEach(key => {
    cloned[key] = deepClone(obj[key]);
  });
  
  return cloned;
};

/**
 * 等待指定时间
 * @param {number} ms - 毫秒数
 * @returns {Promise} Promise对象
 */
export const sleep = (ms) => {
  return new Promise(resolve => setTimeout(resolve, ms));
};

/**
 * 计算分页信息
 * @param {number} total - 总条数
 * @param {number} pageSize - 每页条数
 * @param {number} current - 当前页
 * @returns {object} 分页信息
 */
export const calculatePagination = (total, pageSize, current) => {
  const totalPages = Math.ceil(total / pageSize);
  const hasPrev = current > 1;
  const hasNext = current < totalPages;
  
  return {
    total,
    pageSize,
    current,
    totalPages,
    hasPrev,
    hasNext,
    start: (current - 1) * pageSize + 1,
    end: Math.min(current * pageSize, total),
  };
};